package billeterie;

import com.db4o.Db4oEmbedded;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;
import com.db4o.query.Predicate;
import com.db4o.query.Query;
import java.io.File;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;

/**
 *
 * @author samir
 */
public class Billeterie {

    final static String DataBaseFilePath = System.getProperty("user.dir") + "/Billeterie.db4o";
    static Scanner scan = new Scanner(System.in);
    static final ObjectContainer database = Db4oEmbedded.openFile(Db4oEmbedded.newConfiguration(), DataBaseFilePath);
    static Random rand = new Random();
    static FillDataBase fillData = new FillDataBase();
    public static Billeterie billeterie = new Billeterie();
    public static int idPerson;
    public static int idVoayege;

    /**
     *
     * @param args
     * @throws ParseException
     */
    public static void main(String[] args) throws ParseException {
        System.out.println("PS: La base de données va etre supprimée à la fin de chaque excution pour eviter la duplication de données\nqui vas distabiliser les requetes.\n"
                + "Le billet dans notre conception ne contiens pas des informations personnels, que des IDs de personne, voyage, num siége, date.");
        System.out.println("Press '1' to continue.");
//        scan.next();
        LinkedList<Gare> garesSamples = new LinkedList<>();
        LinkedList<Trajet> trajetSamples = new LinkedList<>();
        LinkedList<Personne> personneSamples = new LinkedList<>();
        LinkedList<Train> trainSamples = new LinkedList<>();
        LinkedList<Voyage> voyageSamples = new LinkedList<>();
        LinkedList<Billet> BilletSamples = new LinkedList<>();
        try {
            // <editor-fold defaultstate="collapsed" desc="Initialisation des gares">

            for (int i = 0; i < 12; i++) {
                String ville = fillData.randomVille();
                int destinations;
                Gare gare;
                Set<Integer> id_Destinations = new HashSet<>();
                for (int j = 0; j < rand.nextInt(9) && j != (destinations = rand.nextInt(9) + 3); j++) {
                    id_Destinations.add(destinations);
                }
                gare = new Gare(i, ville, ville, id_Destinations);
                garesSamples.add(gare);
                database.store(gare);
            }
//            // </editor-fold>
            // <editor-fold defaultstate="collapsed" desc="Initialisation des trajets">
            Trajet trajet;
            String[] villes = fillData.randomVilles();
            for (int i = 0; i < 132; i++) {
                String villeDepart = (villes[i]).substring(0, villes[i].indexOf("#"));
                String villeArrivee = (villes[i]).substring(villes[i].indexOf("#") + 1);
                int destinations, distance = fillData.randomDistance();
                Set<Integer> id_Destinations = new HashSet<>();
                for (int j = 0; j < 10 && j != (destinations = rand.nextInt(12)); j++) {
                    id_Destinations.add(destinations);
                }
                trajet = new Trajet(i, distance, new Gare(rand.nextInt(12), villeDepart, villeDepart, id_Destinations), new Gare(rand.nextInt(12), villeArrivee, villeArrivee, id_Destinations));
                trajetSamples.add(trajet);
                database.store(trajet);
            }
//            // </editor-fold>
            // <editor-fold defaultstate="collapsed" desc="Initialisation des personnes">
            Personne person;
            Map<String, String> fullName = fillData.randomNames();
            Set<String> keys = fullName.keySet();
            idPerson = 0;
            for (String key : keys) {
                ++idPerson;
                //int id_personne, String nom, String prenom, String adresse, String date_naissance, int id_Billet
                person = new Personne(idPerson, fullName.get(key), fillData.randomPrefix() + key, fillData.randomAdresse(), fillData.randomDate(1), (idPerson % 150));
                personneSamples.add(person);
                database.store(person);
            }
            // </editor-fold>
            // <editor-fold defaultstate="collapsed" desc="Initialisation des train">
            Train train;
            for (int i = 0; i < 50; i++) {
                train = new Train(((i + 5) % 50), rand.nextInt(100), fillData.randomType());
                trainSamples.add(train);
                database.store(train);
            }
            // </editor-fold>
            // <editor-fold defaultstate="collapsed" desc="Initialisation des voyage">
            Voyage voyage;
            //(int id_voyage, String date_voyage, Gare gare_arrive, Gare gare_depart, int id_billet, int id_train) {
            for (int i = 0; i < 1000; i++) {
                Gare garedeAriv, garedepart = garesSamples.get(rand.nextInt(garesSamples.size()));
                garedeAriv = garesSamples.get(rand.nextInt(garesSamples.size()));
                voyage = new Voyage(i + 1, fillData.randomDate(2), garedepart, garedeAriv, ((i + 1) % 150), rand.nextInt(50));
                idVoayege++;
                voyageSamples.add(voyage);
                database.store(voyage);
            }
            // </editor-fold>
            // <editor-fold defaultstate="collapsed" desc="Initialisation des billet">
            List<Integer> random = fillData.randomListNumber(201);
            SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
            Billet billet;
            ArrayList idV = new ArrayList();
            for (int i = 0; i < 150 + rand.nextInt(100); i++) {
                int idvoyage = (i % 100);
                while (!idV.contains(idvoyage)) {   //Pour assuer qu'il y aura pas deux numero de siége identique pour le meme train
                    idV.add(idvoyage);
                }
                billet = new Billet(i, ((i * 2) % 100), idvoyage, random.get(i), sdf.parse(fillData.randomDate(2)));
                BilletSamples.add(billet);
                database.store(billet);
            }
            // </editor-fold>

            System.out.println("Options:\n1: Saisie un nouveau billet:\n2: Calcul et affichage du nombre total de billets:"
                    + "\n3: Visualisation de l’ensemble des billets:\n4: Modification d’un billet:\n5: Calcul du tarif d’un billet:"
                    + "\n6: Suppression d’un billet:\n7: Les destinations au départ de 'Paris':\n8: Les prix des différents billets:"
                    + "\n9: La liste des destinations à moins de x km:\n10: Les trajets faits par une personne identifiée par son nom."
                    + "\n11: Trouver les trajets par deux personnes identifiés par leurs noms"
                    + "\n12: Sortir.");
            int choix = scan.nextInt();
            while (choix < 12) {
                switch (choix) {
                    case 1:
                        billeterie.ajouterBillet();
                        break;
                    case 2:
                        billeterie.displayNumberOfBillet();
                        break;
                    case 3:
                        Query qq = database.query();
                        qq.constrain(Billet.class);
                        ObjectSet c = qq.execute();
                        for (Object object : c) {
                            System.out.println(object);
                        }
                        break;
                    case 4:
                        billeterie.modificationBillet();
                        break;
                    case 5:
                        Query q = database.query();
                        q.constrain(Billet.class);
                        ObjectSet r = q.execute();
                        for (Object object : r) {
                            System.out.println(object);
                        }
                        System.out.println("-----------------------------------------------------\n"
                                + "Ci-dessus la liste de billets enregistré dans la base:\n"
                                + "Veillez le id-billet que vous voulez voir les details.");
                        billeterie.displayUnBilletEtDetail(scan.nextInt());
                        break;
                    case 6:
                        Query qu = database.query();
                        qu.constrain(Billet.class);
                        ObjectSet res = qu.execute();
                        for (Object object : res) {
                            System.out.println(object);
                        }
                        System.out.println("Ci dessus la liste des billets sauvegardés;");
                        System.out.println("Introduisez le id_billet que vous voulez supprimer");
                        billeterie.suppressionBillet(scan.nextInt());
                        break;
                    case 7:
                        billeterie.destinationDepartParis();
                        break;
                    case 8:
                        billeterie.displayAllBilletEtDetail();
                        break;
                    case 9:
                        System.out.println("Veillez saisissez la distance:");
                        billeterie.destinationsMoinsDeXKm(scan.nextInt());
                        break;
                    case 10:
                        Query allPersons = database.query();
                        allPersons.constrain(Personne.class);
                        ObjectSet re = allPersons.execute();
                        for (Object object : re) {
                            Personne p = (Personne) object;
                            System.out.println(p.getNom() + ", " + p.getPrenom());
                        }
                        System.out.println("-----------------------------------------------------\n"
                                + "Ci-dessus la liste de personnes enregistré dans la base:\n"
                                + "Veillez inserer le nom et le prenom succesivement.");
                        billeterie.displayTrajetParNomPersonne(scan.next(), scan.next());
                        break;
                    case 11:
                        billeterie.displayTrajetParDeuxPersonne();
                        break;
                    default:
                        System.out.println("Choix entre 1 et 10.\nSystem will exit.");
                        System.exit(0);
                        break;
                }
                System.out.println("----------------------------------------------");
                System.out.println("Options:\n1: Saisie un nouveau billet:\n2: Calcul et affichage du nombre total de billets:"
                    + "\n3: Visualisation de l’ensemble des billets:\n4: Modification d’un billet:\n5: Calcul du tarif d’un billet:"
                    + "\n6: Suppression d’un billet:\n7: Les destinations au départ de 'Paris':\n8: Les prix des différents billets:"
                    + "\n9: La liste des destinations à moins de x km:\n10: Les trajets faits par une personne identifiée par son nom."
                    + "\n11: Trouver les trajets par deux personnes identifiés par leurs noms"
                    + "\n12: Sortir.");
                choix = scan.nextInt();
            }

        } finally {
            database.close();
            File file = new File(DataBaseFilePath);
            if (file.delete()) {
                System.out.println("-----------------------------------\n-----------------------------------\n" + file.getName() + " is deleted!\n-----------------------------------\n-----------------------------------");
            } else {
                System.out.println("Delete operation is failed.");
            }
        }
    }

    public void displayAllBilletEtDetail() {
        Query billetQuery = database.query();
        billetQuery.constrain(Billet.class);
        ObjectSet result = billetQuery.execute();
        System.out.println("Il y a :" + result.size() + " Billets dans la base.");
        for (Object object : result) {
            final Billet leBillet = (Billet) object;
            Query voayegeDUnBillet = database.query();
            voayegeDUnBillet.constrain(new Voyage(leBillet.id_voyage, null, null, null, 0, 0));
            ObjectSet voyages = voayegeDUnBillet.execute();
            final Voyage LeVoayegeDeBillet = (Voyage) voyages.next();
            Predicate<Trajet> leTrajetDeBillet = new Predicate<Trajet>() {
                @Override
                public boolean match(Trajet trajet) {
                    return trajet.gare_arrive.getNom_gare().equals(LeVoayegeDeBillet.gare_arrive.getNom_gare())
                            && trajet.gare_depart.getNom_gare().equals(LeVoayegeDeBillet.gare_depart.getNom_gare());
                }
            };
            ObjectSet trajetsBillet = database.query(leTrajetDeBillet);
            Voyage leVoyageDeBillet = (Voyage) voyages.get(0);
            if (trajetsBillet.size() > 0) {
                Trajet tra = (Trajet) trajetsBillet.next();
                System.out.println("Le " + leBillet + "\nDate de voyage: " + leVoyageDeBillet.getDate_voyage());
                System.out.println("Trajet du billet entre '" + tra.getGare_depart().getNom_gare() + "' et '" + tra.getGare_arrive().getNom_gare()
                        + "'.\nDistance " + tra.getDistance() + " Km.");
                Query typeTrain = database.query();
                typeTrain.constrain(new Train(leVoyageDeBillet.getId_train(), 0, null));
                ObjectSet traintype = typeTrain.execute();
                Train typTrain = (Train) traintype.next();
                System.out.println("Type de train:" + typTrain.getType_train() + "\nPrix (€)" + tra.calculer_cout(typTrain.getType_train()));
                System.out.println("--------------------------------------------------------------");
            }
        }
    }

    public void displayNumberOfBillet() {
        Query billetQuery = database.query();
        billetQuery.constrain(Billet.class);
        ObjectSet result = billetQuery.execute();
        System.out.println("--------------------------------------------------------------");
        System.out.println("Il y a :" + result.size() + " Billets dans la base.");
        System.out.println("--------------------------------------------------------------");
    }

    public void displayUnBilletEtDetail(int idBillet) {
        Query billetQuery = database.query();
        billetQuery.constrain(Billet.class);
        billetQuery.descend("id_billet").constrain(idBillet);
        ObjectSet result = billetQuery.execute();
        System.out.println("-----------------------------------");
        for (Object object : result) {
            final Billet leBillet = (Billet) object;
            Query voayegeDUnBillet = database.query();
            voayegeDUnBillet.constrain(new Voyage(leBillet.id_voyage, null, null, null, 0, 0));
            ObjectSet voyages = voayegeDUnBillet.execute();
            final Voyage LeVoayegeDeBillet = (Voyage) voyages.get(0);
            Predicate<Trajet> leTrajetDeBillet = new Predicate<Trajet>() {
                @Override
                public boolean match(Trajet trajet) {
                    return trajet.gare_arrive.getNom_gare().equals(LeVoayegeDeBillet.gare_arrive.getNom_gare())
                            && trajet.gare_depart.getNom_gare().equals(LeVoayegeDeBillet.gare_depart.getNom_gare());
                }
            };
            ObjectSet trajetsBillet = database.query(leTrajetDeBillet);
            Voyage leVoyageDeBillet = (Voyage) voyages.get(0);
            if (trajetsBillet.size() > 0) {
                Trajet tra = (Trajet) trajetsBillet.get(0);
                System.out.println("Le " + leBillet + "\nDate de voyage: " + leVoyageDeBillet.getDate_voyage());
                System.out.println("Trajet du billet entre " + tra.getGare_depart().getNom_gare() + " et " + tra.getGare_arrive().getNom_gare()
                        + " Distance " + tra.getDistance() + "Km");
                Query typeTrain = database.query();
                typeTrain.constrain(new Train(leVoyageDeBillet.getId_train(), 0, null));
                ObjectSet traintype = typeTrain.execute();
                Train typTrain = (Train) traintype.get(0);
                System.out.println("Type de train:" + typTrain.getType_train() + "\nPrix (€)" + tra.calculer_cout(typTrain.getType_train()));
            }
        }
    }

    public void displayTrajetParNomPersonne(String nom, String prenom) {
        Query billetQuery = database.query();
        billetQuery.constrain(Personne.class);
        billetQuery.descend("nom").constrain(nom);
        billetQuery.descend("prenom").constrain(prenom);
        ObjectSet result = billetQuery.execute();
        for (Object object : result) {
            final Personne person = (Personne) object;
            System.out.println("\n\nDetails:\n_______\n------\n" + person.getNom() + ", " + person.getPrenom() + ". " + person.getAdresse() + "\na fait ces trajets:\n");
            Query voayegeDUnePersonne = database.query();
            voayegeDUnePersonne.constrain(new Voyage(0, null, null, null, person.getId_Billet(), 0));
            ObjectSet voyages = voayegeDUnePersonne.execute();
            for (Object object1 : voyages) {
                final Voyage LeVoyageDeBillet = (Voyage) object1;
                Predicate<Trajet> leTrajetDeBillet = new Predicate<Trajet>() {
                    @Override
                    public boolean match(Trajet trajet) {
                        return trajet.gare_arrive.getNom_gare().equals(LeVoyageDeBillet.gare_arrive.getNom_gare())
                                && trajet.gare_depart.getNom_gare().equals(LeVoyageDeBillet.gare_depart.getNom_gare());
                    }
                };
                ObjectSet trajetsBillet = database.query(leTrajetDeBillet);
                Voyage leVoyageDeBillet = (Voyage) object1;
                if (trajetsBillet.size() > 0) {
                    Trajet tra = (Trajet) trajetsBillet.get(0);
                    System.out.println("----------------------------------------------");
                    System.out.println("Trajet du billet entre \"" + tra.getGare_depart().getNom_gare() + "\" et \"" + tra.getGare_arrive().getNom_gare() + "\""
                            + "\nDistance: " + tra.getDistance() + " Kilométre.");
                    Query typeTrain = database.query();
                    typeTrain.constrain(new Train(leVoyageDeBillet.getId_train(), 0, null));
                    ObjectSet traintype = typeTrain.execute();
                    Train typTrain = (Train) traintype.get(0);
                    System.out.println("Type de train:" + typTrain.getType_train() + "\tPrix (€)" + tra.calculer_cout(typTrain.getType_train()));
                }
            }
        }
    }

    public void DisplayGaresDepartParis() {
        List<Trajet> re = database.query(new Predicate<Trajet>() {
            @Override
            public boolean match(Trajet trajet) {
                return trajet.getGare_depart().getNom_gare().equals("Paris");
            }
        });
        System.out.println("Les distination a partir de Paris:");
        for (Trajet trajet1 : re) {
            System.out.println("Paris ----- " + trajet1.getGare_arrive().getNom_gare());
        }
    }

    public void destinationsMoinsDeXKm(int distance) {
        Query query = database.query();
        query.constrain(Trajet.class);
        query.descend("distance").constrain(distance).smaller();
        ObjectSet re = query.execute();
        System.out.println("Les distination moin de " + distance + " a partir de chaque ville:\n-----------------------------------------------------");
        for (Object trajet1 : re) {
            Trajet trajet = (Trajet) trajet1;
            System.out.println(trajet.getGare_depart().getNom_gare() + "  ------  " + trajet.getGare_arrive().getNom_gare() + "  -----  " + trajet.getDistance() + " KM");
        }
    }

    public void ajouterBillet() throws ParseException {
        System.out.println("Introduisez le nom et le prenom et l'adresse succesivement.");
        Calendar date = new GregorianCalendar();
        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
        String nom = scan.next(), prenom = scan.next(), adress = scan.next(), dateDePrise = date.getTime().toString();
        Query billetTail = database.query();
        billetTail.constrain(Billet.class);
        ObjectSet re = billetTail.execute();
        int lastBilletId = re.size() + 1;
        //Billet{id_billet=158, id_personne=16, id_voyage=58, num_siege=95, dateDePrise=Tue Jan 07 00:00:00 CET 2014}
        //Personne{id_personne=59, nom=Dubois, prenom=PiereBouvant, adresse=62 rue 103, Colomiers., date_naissance=24/07/1985, id_Billet=59}
        Query personQuery = database.query();
        personQuery.constrain(Personne.class);
        ObjectSet result = personQuery.execute();
        int idPersonne = result.size() + 1;
        Personne person = new Personne(idPersonne, nom, prenom, adress, fillData.randomDate(1), lastBilletId);
        Query trajet = database.query();
        trajet.constrain(Voyage.class);
        ObjectSet resTrajet = trajet.execute();
        System.out.println("Voici la liste des voyages disponible.");
        for (Object object : resTrajet) {
            Voyage voy = (Voyage) object;
            System.out.println("*id_Voyage :" + voy.getId_voyage() + " -- " + voy.getGare_depart().getNom_gare() + " --- " + voy.getGare_arrive().getNom_gare() + " Le " + voy.getDate_voyage());
        }
        System.out.println("Veillez choisir l' \"id_voyage\" pour ce billet:");
        int id_voyage = scan.nextInt();

        System.out.println("---------------------------------------------\nVeillez choisir un numero de siége");
        int numSiege = scan.nextInt();
        Query siege = database.query();
        siege.constrain(Billet.class);
        siege.descend("num_siege").constrain(numSiege);
        ObjectSet resultsiege = siege.execute();
        System.out.println("Verification la disponiblité de ce siége...\n");
        while (resultsiege.size() > 0) {
            System.out.println("Siege deja occupé, veillez choisir un autre:");
            numSiege = scan.nextInt();
            siege.constrain(Billet.class);
            siege.descend("num_siege").constrain(numSiege);
            resultsiege = siege.execute();
        }
        System.out.println("Siége disponible.");
        Query voyage = database.query();
        voyage.constrain(Voyage.class);
        voyage.descend("id_voyage").constrain(id_voyage);
        ObjectSet resultvoyage = voyage.execute();
        Voyage voyag = (Voyage) resultvoyage.get(0);
        Billet billet = new Billet(lastBilletId, idPersonne, id_voyage, numSiege, sdf.parse(fillData.randomDate(2)));
        System.out.println(person + "\n" + billet + "\n" + voyag);
        System.out.println("Voulez-vous persister ce billet (1 ou 2): \n1 : YES\n2: NO");
        int choix = scan.nextInt();
        switch (choix) {
            case 1: {
                database.store(voyag);
                database.store(billet);
                database.store(person);
                System.out.println("Billet persisté avec succes!!");
                System.out.println("Voulez vous voir la nouvelle liste des billets:(Press 1)");
                int choice = scan.nextInt();
                if (choice == 1) {
                    Query billets = database.query();
                    billets.constrain(Billet.class);
                    ObjectSet resultBillets = billets.execute();
                    for (Object object : resultBillets) {
                        System.out.println(object);
                    }
                }
            }
            break;
            case 2:
                System.out.println("Billet n'a pas été persisté.");
                break;
            default:
                System.out.println("Vous avez pas choisis le bon chifre");
                break;
        }
    }

    public void modificationBillet() {
        Query queryBill = database.query();
        queryBill.constrain(Billet.class);
        ObjectSet re = queryBill.execute();
        for (Object object : re) {
            System.out.println(object);
        }
        System.out.println("Ci-dessus la liste de billets sauvegardés\nveillez choisir \"id_billet\" d'un billet à modifier");
        Query billet = database.query();
        billet.constrain(Billet.class);
        billet.descend("id_billet").constrain(scan.nextInt());
        ObjectSet res = billet.execute();
        Billet bil = (Billet) res.get(0);
        System.out.println("Billet en quastion : " + bil);
        System.out.println("Nouveau idPersonne (< " + idPerson + ") c'est le nombre de personne sauvegardés.");
        int newIdperson = scan.nextInt();
        bil.setId_personne(newIdperson);
        System.out.println("Nouveau idVoyage (< " + idVoayege + "\")");
        int newIdvoyage = scan.nextInt();
        bil.setId_voyage(newIdvoyage);

        System.out.println("Nouveau num siége");
        int newNumSiege = scan.nextInt();
        System.out.println("Verification la disponiblité de ce siége...\n");
        Query siege = database.query();
        siege.constrain(Billet.class);
        siege.descend("num_siege").constrain(newNumSiege);
        ObjectSet resultsiege = siege.execute();
        while (resultsiege.size() > 0) {
            System.out.println("Siege deja occupé, veillez choisir un autre:");
            newNumSiege = scan.nextInt();
            siege.constrain(Billet.class);
            siege.descend("num_siege").constrain(newNumSiege);
            resultsiege = siege.execute();
        }
        System.out.println("Siége disponible.");
        bil.setNum_siege(newNumSiege);
        database.store(bil);
        System.out.println("Nouveau billet : " + bil);
    }

    public void suppressionBillet(int id_billet) {
        Query qa = database.query();
        qa.constrain(Billet.class);
        qa.descend("id_billet").constrain(id_billet);//a voir plus tard
        ObjectSet resa = qa.execute();
        database.delete(resa.get(0));
        System.out.println("Billet supprimé avec succée");
        Query sb = database.query();
        sb.constrain(Billet.class);
        ObjectSet rebs = sb.execute();
        for (Object object : rebs) {
            System.out.println(object);
        }
        System.out.println("Ci dessus la nouvelle liste des billets sauvegardés;");
    }

    public void destinationDepartParis() {
        List<Trajet> re = database.query(new Predicate<Trajet>() {
            @Override
            public boolean match(Trajet trajet) {
                return trajet.getGare_depart().getNom_gare().equals("Paris");
            }
        });
        for (Trajet trajet1 : re) {
            System.out.println(trajet1.gare_arrive.nom_gare);
        }
    }

    public void displayTrajetParDeuxPersonne() {
        LinkedList<Integer> id_voyage = new LinkedList<>();
        LinkedList<Integer> voyageCommun = new LinkedList<>();

        Query g = database.query();
        g.constrain(Personne.class);
        ObjectSet o = g.execute();
        for (Object object : o) {
            System.out.println(object);
        }
        String nom1 = scan.next(), prenom1 = scan.next();
        String nom2 = scan.next(), prenom2 = scan.next();

        Query billetQuery = database.query();
        billetQuery.constrain(Personne.class);
        billetQuery.descend("nom").constrain(nom1).or(billetQuery.descend("nom").constrain(nom2));
        billetQuery.descend("prenom").constrain(prenom1).or(billetQuery.descend("prenom").constrain(prenom2));
        ObjectSet result = billetQuery.execute();
        Personne p1 = (Personne) result.get(0), p2 = (Personne) result.get(1);
        Query billetP1 = database.query();
        billetP1.constrain(new Billet(0, p1.getId_personne(), 0, 0, null));
        ObjectSet billet1 = billetP1.execute();

        for (Object object1 : billet1) {
            Billet b = (Billet) object1;
            Query voyages = database.query();
            voyages.constrain(new Voyage(0, null, null, null, b.getId_billet(), 0));
            ObjectSet voyage1 = voyages.execute();
            Voyage v = (Voyage) voyage1.get(0);
            id_voyage.add(v.id_voyage);
        }
        Query billetP2 = database.query();
        billetP2.constrain(new Billet(0, p2.getId_personne(), 0, 0, null));
        ObjectSet billet2 = billetP2.execute();
        for (Object object2 : billet2) {
            Billet b2 = (Billet) object2;
            Query voyages = database.query();
            voyages.constrain(new Voyage(0, null, null, null, b2.getId_billet(), 0));
            ObjectSet voyage1 = voyages.execute();
            Voyage v2 = (Voyage) voyage1.get(0);
            if (id_voyage.contains(v2.getId_voyage())) {
                voyageCommun.add(v2.getId_voyage());
            }
        }
        for (int i = 0; i < voyageCommun.size(); i++) {
            Query voyages = database.query();
            voyages.constrain(new Voyage(voyageCommun.get(i), null, null, null, 0, 0));
            ObjectSet voyage1 = voyages.execute();
            System.out.println(voyage1.get(0));//stopped here
        }
    }
}
